<!DOCTYPE html>
<html lang="en-us"><head>
    <meta charset='utf-8'>
    <meta name='viewport' content='width=device-width, initial-scale=1'><meta name='description' content='Java设计模式-六大原则 1、单一职能原则（Single Responsibility Principle, SRP） 定义
 There should never be more than one reason for a class to change.
应该有且仅有一个原因引起类的变更（一个接口或类只有一个职责）
 好处
 类的复杂性降低，实现什么职责都有清晰明确的定义； 可读性提高，复杂性降低，那当然可读性提高了； 可维护性提高，可读性提高，那当然更容易维护了； 变更引起的风险降低，变更时必不可少的，如果接口的单一职责做得好，一个接口修改只对相应的实现类有影响，对其他的接口无影响，这对系统的扩展性、维护性都有非常大的帮助。  最佳实践
职责的划分很难，要想完全符合单一职责的设计更难，原则是接口一定要做到单一职责，类的设计尽量做到只有一个原因引起变化
2、里氏替换原则（LiskovSubstitution Principle，LSP） 继承的利与弊
优点：
 代码共享，减少创建类的工作量，每个子类都拥有父类的方法和属性； 提高代码的重用性； 子类可以形似父类，但又异于父类； 提高代码的可扩展性，实现父类的方法就可以“为所欲为”了； 提高产品或项目的开放性。  缺点：
 继承是侵入性的。只要继承，就必须拥有父类的所有属性和方法； 降低代码的灵活性。子类必须拥有父类的属性和方法，让子类自由的世界中多了些约束； 增强了耦合性。当父类的常量、变量和方法被修改时，需要考虑子类的修改，而且在缺乏规范的环境下，这种修改可能带来非常糟糕的结果——大段的代码需要重构。  定义
 If for each object o1 of type S there is an object o2 oftype T such that for all programs P defined in terms of T,the behavior of P is unchanged when o1 issubstituted for o2 then S is a subtype of T.'><title>Java设计模式 六大原则</title>
    
    <link rel='canonical' href='https://archer-wen.github.io/p/java%E8%AE%BE%E8%AE%A1%E6%A8%A1%E5%BC%8F-%E5%85%AD%E5%A4%A7%E5%8E%9F%E5%88%99/'>

<link rel="stylesheet" href="/scss/style.min.css"><meta property='og:title' content='Java设计模式 六大原则'>
<meta property='og:description' content='Java设计模式-六大原则 1、单一职能原则（Single Responsibility Principle, SRP） 定义
 There should never be more than one reason for a class to change.
应该有且仅有一个原因引起类的变更（一个接口或类只有一个职责）
 好处
 类的复杂性降低，实现什么职责都有清晰明确的定义； 可读性提高，复杂性降低，那当然可读性提高了； 可维护性提高，可读性提高，那当然更容易维护了； 变更引起的风险降低，变更时必不可少的，如果接口的单一职责做得好，一个接口修改只对相应的实现类有影响，对其他的接口无影响，这对系统的扩展性、维护性都有非常大的帮助。  最佳实践
职责的划分很难，要想完全符合单一职责的设计更难，原则是接口一定要做到单一职责，类的设计尽量做到只有一个原因引起变化
2、里氏替换原则（LiskovSubstitution Principle，LSP） 继承的利与弊
优点：
 代码共享，减少创建类的工作量，每个子类都拥有父类的方法和属性； 提高代码的重用性； 子类可以形似父类，但又异于父类； 提高代码的可扩展性，实现父类的方法就可以“为所欲为”了； 提高产品或项目的开放性。  缺点：
 继承是侵入性的。只要继承，就必须拥有父类的所有属性和方法； 降低代码的灵活性。子类必须拥有父类的属性和方法，让子类自由的世界中多了些约束； 增强了耦合性。当父类的常量、变量和方法被修改时，需要考虑子类的修改，而且在缺乏规范的环境下，这种修改可能带来非常糟糕的结果——大段的代码需要重构。  定义
 If for each object o1 of type S there is an object o2 oftype T such that for all programs P defined in terms of T,the behavior of P is unchanged when o1 issubstituted for o2 then S is a subtype of T.'>
<meta property='og:url' content='https://archer-wen.github.io/p/java%E8%AE%BE%E8%AE%A1%E6%A8%A1%E5%BC%8F-%E5%85%AD%E5%A4%A7%E5%8E%9F%E5%88%99/'>
<meta property='og:site_name' content='Archer-Wen`s Blog'>
<meta property='og:type' content='article'><meta property='article:section' content='Post' /><meta property='article:published_time' content='2020-10-20T11:13:38&#43;08:00'/><meta property='article:modified_time' content='2020-10-20T11:13:38&#43;08:00'/>
<meta name="twitter:title" content="Java设计模式 六大原则">
<meta name="twitter:description" content="Java设计模式-六大原则 1、单一职能原则（Single Responsibility Principle, SRP） 定义
 There should never be more than one reason for a class to change.
应该有且仅有一个原因引起类的变更（一个接口或类只有一个职责）
 好处
 类的复杂性降低，实现什么职责都有清晰明确的定义； 可读性提高，复杂性降低，那当然可读性提高了； 可维护性提高，可读性提高，那当然更容易维护了； 变更引起的风险降低，变更时必不可少的，如果接口的单一职责做得好，一个接口修改只对相应的实现类有影响，对其他的接口无影响，这对系统的扩展性、维护性都有非常大的帮助。  最佳实践
职责的划分很难，要想完全符合单一职责的设计更难，原则是接口一定要做到单一职责，类的设计尽量做到只有一个原因引起变化
2、里氏替换原则（LiskovSubstitution Principle，LSP） 继承的利与弊
优点：
 代码共享，减少创建类的工作量，每个子类都拥有父类的方法和属性； 提高代码的重用性； 子类可以形似父类，但又异于父类； 提高代码的可扩展性，实现父类的方法就可以“为所欲为”了； 提高产品或项目的开放性。  缺点：
 继承是侵入性的。只要继承，就必须拥有父类的所有属性和方法； 降低代码的灵活性。子类必须拥有父类的属性和方法，让子类自由的世界中多了些约束； 增强了耦合性。当父类的常量、变量和方法被修改时，需要考虑子类的修改，而且在缺乏规范的环境下，这种修改可能带来非常糟糕的结果——大段的代码需要重构。  定义
 If for each object o1 of type S there is an object o2 oftype T such that for all programs P defined in terms of T,the behavior of P is unchanged when o1 issubstituted for o2 then S is a subtype of T."></head><body class="">
        <div class="container flex on-phone--column align-items--flex-start extended article-page with-toolbar">
            <aside class="sidebar left-sidebar sticky">
    <button class="hamburger hamburger--spin" type="button" id="toggle-menu" aria-label="切换菜单">
        <span class="hamburger-box">
            <span class="hamburger-inner"></span>
        </span>
    </button>

    <header class="site-info">
        
            <figure class="site-avatar">
                

                
                    
                    <img src="/img/avatar_hucadcb8414b40dfa229b47341c926a9e3_418021_300x300_resize_q75_box.jpg" width="300"
                        height="300" class="site-logo" loading="lazy" alt="Avatar">
                

                <span class="emoji">🍥</span>
            </figure>
        
        <h1 class="site-name"><a href="https://archer-wen.github.io/">Archer-Wen`s Blog</a></h1>
        <h2 class="site-description">当你知道的越多，你知道你不知道的越多。</h2>
    </header>

    <ol class="menu" id="main-menu">
        
        
        

        <li >
            <a href='https://archer-wen.github.io/'>
                
                    <svg xmlns="http://www.w3.org/2000/svg" class="icon icon-tabler icon-tabler-home" width="24" height="24" viewBox="0 0 24 24" stroke-width="2" stroke="currentColor" fill="none" stroke-linecap="round" stroke-linejoin="round">
  <path stroke="none" d="M0 0h24v24H0z"/>
  <polyline points="5 12 3 12 12 3 21 12 19 12" />
  <path d="M5 12v7a2 2 0 0 0 2 2h10a2 2 0 0 0 2 -2v-7" />
  <path d="M9 21v-6a2 2 0 0 1 2 -2h2a2 2 0 0 1 2 2v6" />
</svg>



                
                <span>Home</span>
            </a>
        </li>
        
        

        <li >
            <a href='https://archer-wen.github.io/about'>
                
                    <svg xmlns="http://www.w3.org/2000/svg" class="icon icon-tabler icon-tabler-user" width="24" height="24" viewBox="0 0 24 24" stroke-width="2" stroke="currentColor" fill="none" stroke-linecap="round" stroke-linejoin="round">
  <path stroke="none" d="M0 0h24v24H0z"/>
  <circle cx="12" cy="7" r="4" />
  <path d="M6 21v-2a4 4 0 0 1 4 -4h4a4 4 0 0 1 4 4v2" />
</svg>



                
                <span>About</span>
            </a>
        </li>
        
        

        <li >
            <a href='https://archer-wen.github.io/archives'>
                
                    <svg xmlns="http://www.w3.org/2000/svg" class="icon icon-tabler icon-tabler-archive" width="24" height="24" viewBox="0 0 24 24" stroke-width="2" stroke="currentColor" fill="none" stroke-linecap="round" stroke-linejoin="round">
  <path stroke="none" d="M0 0h24v24H0z"/>
  <rect x="3" y="4" width="18" height="4" rx="2" />
  <path d="M5 8v10a2 2 0 0 0 2 2h10a2 2 0 0 0 2 -2v-10" />
  <line x1="10" y1="12" x2="14" y2="12" />
</svg>



                
                <span>Archives</span>
            </a>
        </li>
        
    </ol>
</aside>
            <main class="main full-width">
    <div id="article-toolbar">
        <a href="https://archer-wen.github.io/" class="back-home">
            <svg xmlns="http://www.w3.org/2000/svg" class="icon icon-tabler icon-tabler-chevron-left" width="24" height="24" viewBox="0 0 24 24" stroke-width="2" stroke="currentColor" fill="none" stroke-linecap="round" stroke-linejoin="round">
  <path stroke="none" d="M0 0h24v24H0z"/>
  <polyline points="15 6 9 12 15 18" />
</svg>



            <span>Back</span>
        </a>
    </div>

    <article class="main-article">
    <header class="article-header">

    <div class="article-details">
    

    <h2 class="article-title">
        <a href="https://archer-wen.github.io/p/java%E8%AE%BE%E8%AE%A1%E6%A8%A1%E5%BC%8F-%E5%85%AD%E5%A4%A7%E5%8E%9F%E5%88%99/">Java设计模式 六大原则</a>
    </h2>

    <footer class="article-time">
        <svg xmlns="http://www.w3.org/2000/svg" class="icon icon-tabler icon-tabler-clock" width="24" height="24" viewBox="0 0 24 24" stroke-width="2" stroke="currentColor" fill="none" stroke-linecap="round" stroke-linejoin="round">
  <path stroke="none" d="M0 0h24v24H0z"/>
  <circle cx="12" cy="12" r="9" />
  <polyline points="12 7 12 12 15 15" />
</svg>



        <time class="article-time--published">Oct 20, 2020</time>
    </footer></div>
</header>

    <section class="article-content">
    <h2 id="java设计模式-六大原则">Java设计模式-六大原则</h2>
<h4 id="1单一职能原则single-responsibility-principle-srp">1、单一职能原则（Single Responsibility Principle, SRP）</h4>
<p><strong>定义</strong></p>
<blockquote>
<p>There should never be more than one reason for a class to change.</p>
<p>应该有且仅有一个原因引起类的变更（一个接口或类只有一个职责）</p>
</blockquote>
<p><strong>好处</strong></p>
<ol>
<li>类的复杂性降低，实现什么职责都有清晰明确的定义；</li>
<li>可读性提高，复杂性降低，那当然可读性提高了；</li>
<li>可维护性提高，可读性提高，那当然更容易维护了；</li>
<li>变更引起的风险降低，变更时必不可少的，如果接口的单一职责做得好，一个接口修改只对相应的实现类有影响，对其他的接口无影响，这对系统的扩展性、维护性都有非常大的帮助。</li>
</ol>
<p><strong>最佳实践</strong></p>
<p>职责的划分很难，要想完全符合单一职责的设计更难，原则是接口一定要做到单一职责，类的设计尽量做到只有一个原因引起变化</p>
<h4 id="2里氏替换原则liskovsubstitution-principlelsp">2、里氏替换原则（LiskovSubstitution Principle，LSP）</h4>
<p><strong>继承的利与弊</strong></p>
<p>优点：</p>
<ul>
<li>代码共享，减少创建类的工作量，每个子类都拥有父类的方法和属性；</li>
<li>提高代码的重用性；</li>
<li>子类可以形似父类，但又异于父类；</li>
<li>提高代码的可扩展性，实现父类的方法就可以“为所欲为”了；</li>
<li>提高产品或项目的开放性。</li>
</ul>
<p>缺点：</p>
<ul>
<li>继承是侵入性的。只要继承，就必须拥有父类的所有属性和方法；</li>
<li>降低代码的灵活性。子类必须拥有父类的属性和方法，让子类自由的世界中多了些约束；</li>
<li>增强了耦合性。当父类的常量、变量和方法被修改时，需要考虑子类的修改，而且在缺乏规范的环境下，这种修改可能带来非常糟糕的结果——大段的代码需要重构。</li>
</ul>
<p><strong>定义</strong></p>
<blockquote>
<p>If for each object o1 of type S there is an object o2 oftype T such that for all programs P defined in terms of T,the behavior of P is unchanged when o1 issubstituted for o2 then S is a subtype of T.</p>
<p>如果对每一个类型为S的对象o1，都有类型为T的对象o2，使得以T定义的所有程序P在所有的对象o1都代换成o2时，程序P的行为没有发生变化，那么类型S是类型T的子类型。</p>
</blockquote>
<p>以上是LSP&quot;最正宗&quot;的定义，但是可能不太容易理解，它还有另外一种相对清晰明确的定义：</p>
<blockquote>
<p>Functions that use pointers or references to base classes must be able to useobjects of derived classes without knowing it.</p>
<p>所有引用基类的地方必须能透明地使用其子类的对象。</p>
</blockquote>
<p>通俗点讲，只要父类能出现的地方子类就可以出现，而且替换为子类也不会产生任何错误或异常，使用者可能根本就不需要知道是父类还是子类。但是，反过来就不行了，有子类出现的地方，父类未必就能适应。(LSP可以正着用但不能反着用)</p>
<p><strong>规范</strong></p>
<p>里氏替换原则为良好的继承定义了一个规范，一句简单的定义包含了4层含义：</p>
<ul>
<li>子类必须完全实现父类的方法</li>
</ul>
<blockquote>
<p>如果子类不能完整地实现父类的方法，或者父类的某些方法在子类中已经发生“畸变”，则建议断开父子继承关系，采用依赖、聚集、组合等关系代替继承。</p>
</blockquote>
<ul>
<li>子类可以有自己的个性</li>
<li>覆盖或实现父类的方法时输入参数可以被放大(重载而非覆盖)</li>
<li>覆写或实现父类的方法时输出结果可以被缩小</li>
</ul>
<blockquote>
<p>父类的一个方法的返回值是一个类型T，子类的相同方法（重载或覆写）的返回值为S，那么里氏替换原则就要求S必须小于等于T，也就是说，要么S和T是同一个类型，要么S是T的子类。</p>
</blockquote>
<p><strong>最佳实践</strong></p>
<p>在项目中，采用里氏替换原则时，尽量避免子类的“个性”，一旦子类有“个性”，这个子类和父类之间的关系就很难调和了，把子类当做父类使用，子类的“个性”被抹杀——委屈了点；把子类单独作为一个业务来使用，则会让代码间的耦合关系变得扑朔迷离——缺乏类替换的标准。</p>
<h4 id="3依赖倒置原则dependence-inversion-principledip">3、依赖倒置原则（Dependence Inversion Principle,DIP）</h4>
<p><strong>定义</strong></p>
<blockquote>
<p>High level modules should not depend upon low level modules.Both should depend uponabstractions.Abstractions should not depend upon details.Details should depend upon abstractions.</p>
<ul>
<li>高层模块不应该依赖低层模块，两者都应该依赖其抽象；</li>
<li>抽象不应该依赖细节；</li>
<li>细节应该依赖抽象。</li>
</ul>
</blockquote>
<p>更加精简的定义就是“<strong>面向接口编程</strong>”。</p>
<p><strong>依赖的三种写法</strong></p>
<ol>
<li>构造函数传递依赖对象（构造函数注入），在类中通过构造函数声明依赖对象</li>
<li>Setter方法传递依赖对象（Setter依赖注入），在抽象中设置Setter方法声明依赖关系</li>
<li>在接口的方法中声明依赖对象（接口注入）</li>
</ol>
<p><strong>最佳实践</strong></p>
<p>依赖倒置原则的本质就是通过抽象（接口或抽象类）使各个类或模块的实现彼此独立，不互相影响，实现模块间的松耦合，我们怎么在项目中使用这个规则呢？只要遵循以下的几个规则就可以：</p>
<ul>
<li>每个类尽量都有接口或抽象类，或者抽象类和接口两者都具备</li>
</ul>
<blockquote>
<p>这是依赖倒置的基本要求，接口和抽象类都是属于抽象的，有了抽象才可能依赖倒置</p>
</blockquote>
<ul>
<li>变量的表面类型尽量是接口或者是抽象类</li>
<li>任何类都不应该从具体类派生</li>
<li>尽量不要覆写基类的方法</li>
<li>结合里氏替换原则使用</li>
</ul>
<blockquote>
<p>父类出现的地方子类就能出现，再DIP，我们可以得出这样一个通俗的规则： 接口负责定义public属性和方法，并且声明与其他对象的依赖关系，抽象类负责公共构造部分的实现，实现类准确的实现业务逻辑，同时在适当的时候对父类进行细化。</p>
</blockquote>
<p>依赖倒置原则是6个设计原则中最难以实现的原则，它是实现开闭原则的重要途径，依赖倒置原则没有实现，就别想实现对扩展开放，对修改关闭。在项目中，大家只要记住是“面向接口编程”就基本上抓住了依赖倒置原则的核心。</p>
<h4 id="4接口隔离原则interface-segregations-principle-isp">4、接口隔离原则（Interface Segregations Principle, ISP）</h4>
<p><strong>定义</strong></p>
<p>接口隔离原则有以下两种定义：</p>
<blockquote>
<p>Clients should not be forced to depend upon interfaces that they don&rsquo;t use.</p>
<p>客户端不应该依赖它不需要的接口。</p>
</blockquote>
<p>解释：客户端需要什么接口就提供什么接口，把不需要的接口剔除掉，那就需要对接口进行细化，保证其纯洁性；</p>
<blockquote>
<p>The dependency of one class to another one should depend on the smallest possible interface.</p>
<p>类间的依赖关系应该建立在最小的接口上。</p>
</blockquote>
<p>解释：要求是最小的接口，也是要求接口细化，接口纯洁，与第一个定义如出一辙，只是一个事物的两种不同描述。</p>
<p>概括：建立单一接口，不要建立臃肿庞大的接口。再通俗一点讲：接口尽量细化，同时接口中的方法尽量少。</p>
<p><strong>接口隔离原则 VS 单一职责原则</strong></p>
<ul>
<li>接口隔离原则与单一职责的审视角度是不相同的</li>
<li>单一职责要求的是类和接口职责单一，注重的是职责，这是业务逻辑上的划分；</li>
<li>接口隔离原则要求接口的方法尽量少。</li>
</ul>
<p>例如一个接口的职责可能包含10个方法，这10个方法都放在一个接口中，并且提供给多个模块访问，各个模块按照规定的权限来访问，在系统外通过文档约束“不使用的方法不要访问”，按照单一职责原则是允许的，按照接口隔离原则是不允许的，因为它要求“尽量使用多个专门的接口”。专门的接口指什么？就是指提供给每个模块的都应该是单一接口，提供给几个模块就应该有几个接口，而不是建立一个庞大的臃肿的接口，容纳所有的客户端访问。</p>
<p>规范</p>
<ul>
<li>接口要尽量小
<ul>
<li>要有限度</li>
<li>不能违背单一职责原则（业务上的划分）</li>
</ul>
</li>
<li>接口要高内聚
<ul>
<li>高内聚具体到接口隔离原则就是，要求在接口中尽量少公布public方法，接口是对外的承诺，承诺越少对系统的开发越有利，变更的风险也就越少，同时也有利于降低成本。</li>
</ul>
</li>
<li>定制服务（只提供访问者需要的方法）
<ul>
<li>举例说明：一个用于查询用户的接口，应该提供具体的根据用户ID查询或者根据用户名查询等于业务相关的特定接口，而不是提供一个带有Map（或者说类似Mybatis Example）参数的查询接口</li>
</ul>
</li>
<li>接口设计是有限度的
<ul>
<li>接口的设计粒度越小，系统越灵活；</li>
<li>但是，灵活的同时也带来了结构的复杂化，开发难度增加，可维护性降低，这不是一个项目或产品所期望看到的；</li>
<li>所以接口设计一定要注意适度，这个“度”如何来判断呢？根据经验和常识判断，没有一个固化或可测量的标准。</li>
</ul>
</li>
</ul>
<p><strong>最佳实践</strong></p>
<p>接口隔离原则是对接口的定义，同时也是对类的定义，接口和类尽量使用原子接口或原子类来组装。但是，这个原子该怎么划分是设计模式中的一大难题，在实践中可以根据以下几个规则来衡量：</p>
<ul>
<li>一个接口只服务于一个子模块或业务逻辑；</li>
<li>通过业务逻辑压缩接口中的public方法，接口时常去回顾，尽量让接口达到“满身筋骨肉”，而不是“肥嘟嘟”的一大堆方法；</li>
<li>已经被污染了的接口，尽量去修改，若变更的风险较大，则采用适配器模式进行转化处理；</li>
<li>了解环境，拒绝盲从。每个项目或产品都有特定的环境因素，环境不同，接口拆分的标准就不同。深入了解业务逻辑，结合实际情况进行接口设计。</li>
</ul>
<h4 id="5迪米特法则law-of-demeterlod">5、迪米特法则（Law of Demeter，LoD）</h4>
<blockquote>
<p>也称为最少知识原则（Least KnowledgePrinciple，LKP）</p>
</blockquote>
<p><strong>定义</strong></p>
<blockquote>
<p>一个对象应该对其他对象有最少的了解</p>
</blockquote>
<p>通俗地讲，一个类应该对自己需要耦合或调用的类知道得最少，你（被耦合或调用的类）的内部是如何复杂都和我没关系，那是你的事情，我就知道你提供的这么多public方法，我就调用这么多，其他的我一概不关心。</p>
<p><strong>含义</strong></p>
<ul>
<li>只和朋友交流</li>
</ul>
<pre><code>迪米特法则还有一个英文解释是：

Only talk to your immediate friends.
只与直接的朋友通信。
</code></pre><p>一个类只和朋友交流，不与陌生类交流，不要出现getA().getB().getC().getD()这种情况（在一种极端的情况下允许出现这种访问，即每一个点号后面的返回类型都相同），类与类之间的关系是建立在类间的，而不是方法间，因此一个方法尽量不引入一个类中不存在的对象，当然，JDK API提供的类除外。</p>
<ul>
<li>朋友间也是有距离的<!-- raw HTML omitted -->
迪米特法则要求类“羞涩”一点，尽量不要对外公布太多的public方法和非静态的public变量，尽量内敛，多使用private、package-private、protected等访问权限。</li>
<li>是自己的就是自己的<!-- raw HTML omitted -->
在实际应用中经常会出现这样一个方法：放在本类中也可以，放在其他类中也没有错，那怎么去衡量呢？你可以坚持这样一个原则：如果一个方法放在本类中，既不增加类间关系，也对本类不产生负面影响，那就放置在本类中。</li>
<li>谨慎使用Serializable</li>
</ul>
<p><strong>最佳实践</strong></p>
<ul>
<li>迪米特法则的核心观念就是类间解耦，弱耦合，只有弱耦合了以后，类的复用率才可以提高。其要求的结果就是产生了大量的中转或跳转类，导致系统的复杂性提高，同时也为维护带来了难度。在采用迪米特法则时需要反复权衡，既做到让结构清晰，又做到高内聚低耦合。</li>
<li>迪米特法则要求类间解耦，但解耦是有限度的，除非是计算机的最小单元——二进制的0和1。那才是完全解耦，在实际的项目中，需要适度地考虑这个原则，别为了套用原则而做项目。原则只是供参考，如果违背了这个原则，项目也未必会失败，这就需要大家在采用原则时反复度量，不遵循是不对的，严格执行就是“过犹不及”。</li>
</ul>
<h4 id="6开闭原则open-closed-principle-ocp">6、开闭原则（Open Closed Principle, OCP）</h4>
<blockquote>
<p>开闭原则是Java世界里最基础的设计原则，它指导我们如何建立一个稳定的、灵活的系统</p>
</blockquote>
<p><strong>定义</strong></p>
<blockquote>
<p>Software entities like classes,modules and functions should be open for extension but closed formodifications.</p>
<p>一个软件实体如类、模块和函数应该对扩展开放，对修改关闭。</p>
</blockquote>
<p>换句话说，一个软件实体应该通过扩展来实现变化，而不是通过修改已有的代码来实现变化。</p>
<p><strong>重要性</strong></p>
<p>开闭原则是最基础的一个原则，前面节介绍的五个原则都是开闭原则的具体形态，也就是说前五个原则就是指导设计的工具和方法，而开闭原则才是其精神领袖。换一个角度来理解，依照Java语言的称谓，开闭原则是抽象类，其他五大原则是具体的实现类，开闭原则在面向对象设计领域中的地位就类似于牛顿第一定律在力学、勾股定律在几何学、质能方程在狭义相对论中的地位，其地位无人能及。</p>
<p><strong>如何使用开闭原则</strong></p>
<ul>
<li>抽象约束
<ul>
<li>通过接口或抽象类约束扩展，对扩展进行边界限定，不允许出现在接口或抽象类中不存在的public方法；</li>
<li>参数类型、引用对象尽量使用接口或者抽象类，而不是实现类；</li>
<li>抽象层尽量保持稳定，一旦确定即不允许修改。</li>
</ul>
</li>
<li>元数据（metadata）控制模块行为<!-- raw HTML omitted -->
何谓元数据？就是用来描述环境和数据的数据，通俗地说就是配置参数，参数可以从文件中获得，也可以从数据库中获得。</li>
<li>制定项目章程（团队约定）</li>
<li>封装变化
<ul>
<li>将相同的变化封装到一个接口或抽象类中；</li>
<li>将不同的变化封装到不同的接口或抽象类中，不应该有两个不同的变化出现在同一个接口或抽象类中。</li>
<li>封装变化，也就是受保护的变化（protected variations），找出预计有变化或不稳定的点，我们为这些变化点创建稳定的接口，准确地讲是封装可能发生的变化，一旦预测到或“第六感”发觉有变化，就可以进行封装，23个设计模式都是从各个不同的角度对变化进行封装的</li>
</ul>
</li>
</ul>
<p><strong>最佳实践</strong></p>
<ul>
<li>
<p>开闭原则也只是一个原则<!-- raw HTML omitted -->
开闭原则只是精神口号，实现拥抱变化的方法非常多，并不局限于这6大设计原则，但是遵循这6大设计原则基本上可以应对大多数变化。因此，我们在项目中应尽量采用这6大原则，适当时候可以进行扩充，例如通过类文件替换的方式完全可以解决系统中的一些缺陷。大家在开发中比较常用的修复缺陷的方法就是类替换，比如一个软件产品已经在运行中，发现了一个缺陷，需要修正怎么办？如果有自动更新功能，则可以下载一个.class文件直接覆盖原有的class，重新启动应用（也不一定非要重新启动）就可以解决问题，也就是通过类文件的替换方式修正了一个缺陷，当然这种方式也可以应用到项目中，正在运行中的项目发现需要增加一个新功能，通过修改原有实现类的方式就可以解决这个问题，前提条件是：类必须做到高内聚、低耦合，否则类文件的替换会引起不可预料的故障。</p>
</li>
<li>
<p>项目规章非常重要<!-- raw HTML omitted -->
如果你是一位项目经理或架构师，应尽量让自己的项目成员稳定，稳定后才能建立高效的团队文化，章程是一个团队所有成员共同的知识结晶，也是所有成员必须遵守的约定。优秀的章程能带给项目带来非常多的好处，如提高开发效率、降低缺陷率、提高团队士气、提高技术成员水平，等等。</p>
</li>
<li>
<p>预知变化<!-- raw HTML omitted -->
在实践中过程中，架构师或项目经理一旦发现有发生变化的可能，或者变化曾经发生过，则需要考虑现有的架构是否可以轻松地实现这一变化。架构师设计一套系统不仅要符合现有的需求，还要适应可能发生的变化，这才是一个优良的架构。</p>
</li>
</ul>
<p>开闭原则是一个终极目标，任何人包括大师级人物都无法百分之百做到，但朝这个方向努力，可以非常显著地改善一个系统的架构，真正做到“拥抱变化”。</p>
<h4 id="7总结">7、总结</h4>
<p>首先，无论是6大设计原则还是23种设计模式，根本目标其实就是一个&quot;<strong>拥抱变化</strong>&quot;，包括需求的变化、运行环境的变化、性能要求的提升等等，实现一个需求并不难，但是当变化来临时，能否泰然处之，那就是个技术活了。</p>
<p>其次，&ldquo;拥抱变化&quot;落实到代码层面是什么？——你的代码是<strong>可维护的、可扩展的</strong>，还是说&quot;牵一发动全身&rdquo;，一点小的改动很多东西都要跟着变动。</p>
<p>再次，要做到&quot;拥抱变化&quot;，让你的代码很容易维护和扩展，核心理念就是&quot;<strong>高内聚、低耦合</strong>&quot;，以及&quot;<strong>面向接口编程（面向抽象编程）</strong>”</p>
<p>最后，设计原则、设计模式是前辈总结的&quot;经验&quot;，但不是&quot;条款&quot;，尽可能遵循这些规范会让你的设计无限接近完美，但世界上本就没有十全十美的东西，凡事都要有个度，不要认死理，不要为了&quot;套模式&quot;而应用设计模式，要具体问题具体分析，根据实际情况进行权衡。</p>
<blockquote>
<p>设计做得再漂亮，代码写得再完美，项目做得再符合标准，一旦项目亏本，产品投入大于产出，那整体就是扯淡！</p>
</blockquote>
<pre><code>感谢：@segmentfault_tianranll
</code></pre>
</section>


    <footer class="article-footer">
    

    
    <section class="article-copyright">
        <svg xmlns="http://www.w3.org/2000/svg" class="icon icon-tabler icon-tabler-copyright" width="24" height="24" viewBox="0 0 24 24" stroke-width="2" stroke="currentColor" fill="none" stroke-linecap="round" stroke-linejoin="round">
  <path stroke="none" d="M0 0h24v24H0z"/>
  <circle cx="12" cy="12" r="9" />
  <path d="M14.5 9a3.5 4 0 1 0 0 6" />
</svg>



        <span>Licensed under CC BY-NC-SA 4.0</span>
    </section>
    </footer>

    
</article>

    <aside class="related-contents--wrapper">
    
    
</aside>

    
        
    <div class="disqus-container">
    <div id="disqus_thread"></div>
<script type="application/javascript">
    var disqus_config = function () {
    
    
    
    };
    (function() {
        if (["localhost", "127.0.0.1"].indexOf(window.location.hostname) != -1) {
            document.getElementById('disqus_thread').innerHTML = 'Disqus comments not available by default when the website is previewed locally.';
            return;
        }
        var d = document, s = d.createElement('script'); s.async = true;
        s.src = '//' + "hugo-theme-stack" + '.disqus.com/embed.js';
        s.setAttribute('data-timestamp', +new Date());
        (d.head || d.body).appendChild(s);
    })();
</script>
<noscript>Please enable JavaScript to view the <a href="https://disqus.com/?ref_noscript">comments powered by Disqus.</a></noscript>
<a href="https://disqus.com" class="dsq-brlink">comments powered by <span class="logo-disqus">Disqus</span></a>
</div>

<style>
    .disqus-container {
        background-color: var(--card-background);
        border-radius: var(--card-border-radius);
        box-shadow: var(--shadow-l1);
        padding: var(--card-padding);
    }
</style>


    

    <footer class="site-footer">
    <section class="copyright">&copy; 2020 Archer-Wen`s Blog</section>
    <section class="powerby">
        Built with <a href="https://gohugo.io/" target="_blank" rel="noopener">Hugo</a> <br />
        Theme <b><a href="https://github.com/CaiJimmy/hugo-theme-stack" target="_blank" rel="noopener" data-version="1.0.5">Stack</a></b> designed by
        <a href="https://jimmycai.com" target="_blank" rel="noopener">Jimmy</a>
    </section>
</footer>
<div class="pswp" tabindex="-1" role="dialog" aria-hidden="true" style="display:none">

    
    <div class="pswp__bg"></div>

    
    <div class="pswp__scroll-wrap">

        
        <div class="pswp__container">
            <div class="pswp__item"></div>
            <div class="pswp__item"></div>
            <div class="pswp__item"></div>
        </div>

        
        <div class="pswp__ui pswp__ui--hidden">

            <div class="pswp__top-bar">

                

                <div class="pswp__counter"></div>

                <button class="pswp__button pswp__button--close" title="Close (Esc)"></button>

                <button class="pswp__button pswp__button--share" title="Share"></button>

                <button class="pswp__button pswp__button--fs" title="Toggle fullscreen"></button>

                <button class="pswp__button pswp__button--zoom" title="Zoom in/out"></button>

                
                
                <div class="pswp__preloader">
                    <div class="pswp__preloader__icn">
                        <div class="pswp__preloader__cut">
                            <div class="pswp__preloader__donut"></div>
                        </div>
                    </div>
                </div>
            </div>

            <div class="pswp__share-modal pswp__share-modal--hidden pswp__single-tap">
                <div class="pswp__share-tooltip"></div>
            </div>

            <button class="pswp__button pswp__button--arrow--left" title="Previous (arrow left)">
            </button>

            <button class="pswp__button pswp__button--arrow--right" title="Next (arrow right)">
            </button>

            <div class="pswp__caption">
                <div class="pswp__caption__center"></div>
            </div>

        </div>

    </div>

</div>
            </main>
        </div>
        <script src="https://cdn.jsdelivr.net/npm/node-vibrant@3.1.5/dist/vibrant.min.js"
    integrity="sha256-5NovOZc4iwiAWTYIFiIM7DxKUXKWvpVEuMEPLzcm5/g=" crossorigin="anonymous"></script><script type="text/javascript" src="/ts/main.js" defer></script>
<script>
    (function () {
        const customFont = document.createElement('link');
        customFont.href = "https://fonts.googleapis.com/css2?family=Lato:wght@300;400;700&display=swap";

        customFont.type = "text/css";
        customFont.rel = "stylesheet";

        document.head.appendChild(customFont);
    }());
</script>
<link rel="stylesheet" href="/css/highlight/light.min.css" media="(prefers-color-scheme: light)">
<link rel="stylesheet" href="/css/highlight/dark.min.css" media="(prefers-color-scheme: dark)">

    </body>
</html>
